home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr48 / bpl70n12.zip / ARISOURC.ZIP / FPRED.ASM < prev    next >
Assembly Source File  |  1993-03-07  |  4KB  |  87 lines
  1.  
  2. ; *******************************************************
  3. ; *                                                     *
  4. ; *     Turbo Pascal Runtime Library Version 7.0        *
  5. ; *     Real Multiple Precision Argument Reduction      *
  6. ; *                                                     *
  7. ; *     Copyright (C) 1991-1993 Norbert Juffa           *
  8. ; *                                                     *
  9. ; *******************************************************
  10.  
  11.              TITLE   FPRED
  12.  
  13.  
  14. CODE         SEGMENT BYTE PUBLIC
  15.  
  16.              ASSUME  CS:CODE
  17.  
  18. ; Externals
  19.  
  20.              EXTRN   RealAdd:NEAR,RealMulNoChk:NEAR,RealMul:NEAR
  21.  
  22. ; Publics
  23.  
  24.              PUBLIC  RealReduceMP
  25.  
  26.  
  27. ;-----------------------------------------------------------------------------
  28. ; Routine RealReduceMP realizes an extended precision argument reduction as
  29. ; needed in the calculation of trigonometric functions Sin, Cos, and Tan and
  30. ; in the Exp function. In the argument reduction for these functions there is
  31. ; the danger of a great loss of precision due to cancelling when subtracting
  32. ; numbers of nearly equal magnitude. The reduction usually calls for the
  33. ; subtraction of some multiple n of a constant c from the argument x. The
  34. ; precision can be increased if the constant is split into two parts, c1 and
  35. ; c2, with c1 being the most significant part and c2 being the least
  36. ; significant part and c1+c2=c with more bits of precision than there are
  37. ; bits in the mantissa of the floating point format used for the calculations.
  38. ; Instead of computing x - n*c, the calculation is done as x - n*c1 - n*c2,
  39. ; where it is important that n*c1 can be exactly represented in the floating
  40. ; point format used.
  41. ;
  42. ; INPUT:     DX:BX:AX  n
  43. ;            DI:SI:CX  x
  44. ;            CS:BP     Pointer to table containing two REAL constants c1,c2
  45. ;
  46. ; OUTPUT:    DX:BX:AX  x + n*c1 + n*c2
  47. ;
  48. ; DESTROYS:  AX,BX,CX,DX,SI,DI,Flags
  49. ;------------------------------------------------------------------------------
  50.  
  51. RealReduceMP PROC    NEAR
  52.              PUSH    DX                ; save
  53.              PUSH    BX                ;  n on
  54.              PUSH    AX                ;   stack
  55.              PUSH    DI                ; save x
  56.              PUSH    SI                ;  on
  57.              PUSH    CX                ;   stack
  58.              MOV     CX, CS:[BP+0]     ; get c1
  59.              MOV     SI, CS:[BP+2]     ;  from constant table
  60.              MOV     DI, CS:[BP+4]     ;   pointed to by CS:BP
  61.              CALL    RealMulNoChk      ; compute n*c1
  62.              POP     CX                ; get
  63.              POP     SI                ;  back
  64.              POP     DI                ;   x
  65.              CALL    RealAdd           ; compute x + n*c1
  66.              POP     CX                ; get
  67.              POP     SI                ;  back
  68.              POP     DI                ;   n
  69.              PUSH    DX                ; save
  70.              PUSH    BX                ;  x + n*c1
  71.              PUSH    AX                ;   on stack
  72.              MOV     AX, CS:[BP+6]     ; get
  73.              MOV     BX, CS:[BP+8]     ;  c2 from
  74.              MOV     DX, CS:[BP+10]    ;   constant table
  75.              CALL    RealMul           ; compute n*c2
  76.              POP     CX                ; get
  77.              POP     SI                ;  back
  78.              POP     DI                ;   x + n*c1
  79.              JMP     RealAdd           ; compute x + n*c1 + n*c2 and return
  80. RealReduceMP ENDP
  81.  
  82.              ALIGN   4
  83.  
  84. CODE         ENDS
  85.  
  86.              END
  87.